﻿// Decompiled with JetBrains decompiler
// Type: UnityEngine.Debug
// Assembly: UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: E6AE6B5A-2752-4B07-9528-C8B77C62CE79
// Assembly location: C:\Users\windys\Unity\2021.3.39f1c1\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.dll
// XML documentation location: C:\Users\windys\Unity\2021.3.39f1c1\Editor\Data\Managed\UnityEngine\UnityEngine.CoreModule.xml

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using UnityEngine.Bindings;
using UnityEngine.Internal;
using UnityEngine.Scripting;

#nullable disable
namespace UnityEngine
{
  /// <summary>
  ///   <para>Class containing methods to ease debugging while developing a game.</para>
  /// </summary>
  [NativeHeader("Runtime/Export/Debug/Debug.bindings.h")]
  public class Debug
  {
    internal static readonly ILogger s_DefaultLogger = (ILogger) new Logger((ILogHandler) new DebugLogHandler());
    internal static ILogger s_Logger = (ILogger) new Logger((ILogHandler) new DebugLogHandler());

    /// <summary>
    ///   <para>Get default debug logger.</para>
    /// </summary>
    public static ILogger unityLogger => Debug.s_Logger;

    /// <summary>
    ///   <para>Draws a line between specified start and end points.</para>
    /// </summary>
    /// <param name="start">Point in world space where the line should start.</param>
    /// <param name="end">Point in world space where the line should end.</param>
    /// <param name="color">Color of the line.</param>
    /// <param name="duration">How long the line should be visible for.</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration)
    {
      bool depthTest = true;
      Debug.DrawLine(start, end, color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line between specified start and end points.</para>
    /// </summary>
    /// <param name="start">Point in world space where the line should start.</param>
    /// <param name="end">Point in world space where the line should end.</param>
    /// <param name="color">Color of the line.</param>
    /// <param name="duration">How long the line should be visible for.</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawLine(Vector3 start, Vector3 end, Color color)
    {
      bool depthTest = true;
      float duration = 0.0f;
      Debug.DrawLine(start, end, color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line between specified start and end points.</para>
    /// </summary>
    /// <param name="start">Point in world space where the line should start.</param>
    /// <param name="end">Point in world space where the line should end.</param>
    /// <param name="color">Color of the line.</param>
    /// <param name="duration">How long the line should be visible for.</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawLine(Vector3 start, Vector3 end)
    {
      bool depthTest = true;
      float duration = 0.0f;
      Color white = Color.white;
      Debug.DrawLine(start, end, white, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line between specified start and end points.</para>
    /// </summary>
    /// <param name="start">Point in world space where the line should start.</param>
    /// <param name="end">Point in world space where the line should end.</param>
    /// <param name="color">Color of the line.</param>
    /// <param name="duration">How long the line should be visible for.</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [FreeFunction("DebugDrawLine", IsThreadSafe = true)]
    public static void DrawLine(
      Vector3 start,
      Vector3 end,
      [UnityEngine.Internal.DefaultValue("Color.white")] Color color,
      [UnityEngine.Internal.DefaultValue("0.0f")] float duration,
      [UnityEngine.Internal.DefaultValue("true")] bool depthTest)
    {
      Debug.DrawLine_Injected(ref start, ref end, ref color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line from start to start + dir in world coordinates.</para>
    /// </summary>
    /// <param name="start">Point in world space where the ray should start.</param>
    /// <param name="dir">Direction and length of the ray.</param>
    /// <param name="color">Color of the drawn line.</param>
    /// <param name="duration">How long the line will be visible for (in seconds).</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration)
    {
      bool depthTest = true;
      Debug.DrawRay(start, dir, color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line from start to start + dir in world coordinates.</para>
    /// </summary>
    /// <param name="start">Point in world space where the ray should start.</param>
    /// <param name="dir">Direction and length of the ray.</param>
    /// <param name="color">Color of the drawn line.</param>
    /// <param name="duration">How long the line will be visible for (in seconds).</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawRay(Vector3 start, Vector3 dir, Color color)
    {
      bool depthTest = true;
      float duration = 0.0f;
      Debug.DrawRay(start, dir, color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line from start to start + dir in world coordinates.</para>
    /// </summary>
    /// <param name="start">Point in world space where the ray should start.</param>
    /// <param name="dir">Direction and length of the ray.</param>
    /// <param name="color">Color of the drawn line.</param>
    /// <param name="duration">How long the line will be visible for (in seconds).</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    [ExcludeFromDocs]
    public static void DrawRay(Vector3 start, Vector3 dir)
    {
      bool depthTest = true;
      float duration = 0.0f;
      Color white = Color.white;
      Debug.DrawRay(start, dir, white, duration, depthTest);
    }

    /// <summary>
    ///   <para>Draws a line from start to start + dir in world coordinates.</para>
    /// </summary>
    /// <param name="start">Point in world space where the ray should start.</param>
    /// <param name="dir">Direction and length of the ray.</param>
    /// <param name="color">Color of the drawn line.</param>
    /// <param name="duration">How long the line will be visible for (in seconds).</param>
    /// <param name="depthTest">Determines whether objects closer to the camera obscure the line.</param>
    public static void DrawRay(
      Vector3 start,
      Vector3 dir,
      [UnityEngine.Internal.DefaultValue("Color.white")] Color color,
      [UnityEngine.Internal.DefaultValue("0.0f")] float duration,
      [UnityEngine.Internal.DefaultValue("true")] bool depthTest)
    {
      Debug.DrawLine(start, start + dir, color, duration, depthTest);
    }

    /// <summary>
    ///   <para>Pauses the editor.</para>
    /// </summary>
    [FreeFunction("PauseEditor")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern void Break();

    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern void DebugBreak();

    /// <summary>
    ///   <para>Populate an unmanaged buffer with the current managed call stack as a sequence of UTF-8 bytes, without allocating GC memory. Returns the number of bytes written into the buffer.</para>
    /// </summary>
    /// <param name="buffer">Target buffer to receive the callstack text</param>
    /// <param name="bufferMax">Max number of bytes to write</param>
    /// <param name="projectFolder">Project folder path, to clean up path names</param>
    [ThreadSafe]
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern unsafe int ExtractStackTraceNoAlloc(
      byte* buffer,
      int bufferMax,
      string projectFolder);

    /// <summary>
    ///   <para>Logs a message to the Unity Console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void Log(object message) => Debug.unityLogger.Log(LogType.Log, message);

    /// <summary>
    ///   <para>Logs a message to the Unity Console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void Log(object message, Object context)
    {
      Debug.unityLogger.Log(LogType.Log, message, context);
    }

    /// <summary>
    ///   <para>Logs a formatted message to the Unity Console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="logType">Type of message e.g. warn or error etc.</param>
    /// <param name="logOptions">Option flags to treat the log message special.</param>
    public static void LogFormat(string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Log, format, args);
    }

    /// <summary>
    ///   <para>Logs a formatted message to the Unity Console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="logType">Type of message e.g. warn or error etc.</param>
    /// <param name="logOptions">Option flags to treat the log message special.</param>
    public static void LogFormat(Object context, string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Log, context, format, args);
    }

    /// <summary>
    ///   <para>Logs a formatted message to the Unity Console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="logType">Type of message e.g. warn or error etc.</param>
    /// <param name="logOptions">Option flags to treat the log message special.</param>
    public static void LogFormat(
      LogType logType,
      LogOption logOptions,
      Object context,
      string format,
      params object[] args)
    {
      if (!(Debug.unityLogger.logHandler is DebugLogHandler logHandler))
      {
        Debug.unityLogger.LogFormat(logType, context, format, args);
      }
      else
      {
        if (!Debug.unityLogger.IsLogTypeAllowed(logType))
          return;
        logHandler.LogFormat(logType, logOptions, context, format, args);
      }
    }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an error message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogError(object message) => Debug.unityLogger.Log(LogType.Error, message);

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an error message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogError(object message, Object context)
    {
      Debug.unityLogger.Log(LogType.Error, message, context);
    }

    /// <summary>
    ///   <para>Logs a formatted error message to the Unity console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogErrorFormat(string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Error, format, args);
    }

    /// <summary>
    ///   <para>Logs a formatted error message to the Unity console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogErrorFormat(Object context, string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Error, context, format, args);
    }

    internal static void LogError(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber)
    {
      Debug.LogCompilerError(message, fileName, lineNumber, columnNumber);
    }

    internal static void LogWarning(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber)
    {
      Debug.LogCompilerWarning(message, fileName, lineNumber, columnNumber);
    }

    internal static void LogInfo(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber)
    {
      Debug.LogInformation(message, fileName, lineNumber, columnNumber);
    }

    [MethodImpl(MethodImplOptions.InternalCall)]
    internal static extern void LogCompilerMessage(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber,
      bool forEditor,
      bool isError,
      int identifier,
      int instanceId);

    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern void LogCompilerWarning(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber);

    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern void LogCompilerError(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber);

    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern void LogInformation(
      string message,
      string fileName,
      int lineNumber,
      int columnNumber);

    /// <summary>
    ///   <para>Clears errors from the developer console.</para>
    /// </summary>
    [MethodImpl(MethodImplOptions.InternalCall)]
    public static extern void ClearDeveloperConsole();

    /// <summary>
    ///   <para>Reports whether the development console is visible. The development console cannot be made to appear using:</para>
    /// </summary>
    public static extern bool developerConsoleVisible { [MethodImpl(MethodImplOptions.InternalCall)] get; [MethodImpl(MethodImplOptions.InternalCall)] set; }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an error message to the console.</para>
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="exception">Runtime Exception.</param>
    public static void LogException(Exception exception)
    {
      Debug.unityLogger.LogException(exception, (Object) null);
    }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an error message to the console.</para>
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="exception">Runtime Exception.</param>
    public static void LogException(Exception exception, Object context)
    {
      Debug.unityLogger.LogException(exception, context);
    }

    [MethodImpl(MethodImplOptions.InternalCall)]
    internal static extern void LogPlayerBuildError(
      string message,
      string file,
      int line,
      int column);

    /// <summary>
    ///   <para>A variant of Debug.Log that logs a warning message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogWarning(object message)
    {
      Debug.unityLogger.Log(LogType.Warning, message);
    }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs a warning message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogWarning(object message, Object context)
    {
      Debug.unityLogger.Log(LogType.Warning, message, context);
    }

    /// <summary>
    ///   <para>Logs a formatted warning message to the Unity Console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogWarningFormat(string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Warning, format, args);
    }

    /// <summary>
    ///   <para>Logs a formatted warning message to the Unity Console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    public static void LogWarningFormat(Object context, string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Warning, context, format, args);
    }

    /// <summary>
    ///   <para>Assert a condition and logs an error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, (object) "Assertion failed");
    }

    /// <summary>
    ///   <para>Assert a condition and logs an error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition, Object context)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, (object) "Assertion failed", context);
    }

    /// <summary>
    ///   <para>Assert a condition and logs an error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition, object message)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, message);
    }

    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition, string message)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, (object) message);
    }

    /// <summary>
    ///   <para>Assert a condition and logs an error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition, object message, Object context)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, message, context);
    }

    [Conditional("UNITY_ASSERTIONS")]
    public static void Assert(bool condition, string message, Object context)
    {
      if (condition)
        return;
      Debug.unityLogger.Log(LogType.Assert, (object) message, context);
    }

    /// <summary>
    ///   <para>Assert a condition and logs a formatted error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void AssertFormat(bool condition, string format, params object[] args)
    {
      if (condition)
        return;
      Debug.unityLogger.LogFormat(LogType.Assert, format, args);
    }

    /// <summary>
    ///   <para>Assert a condition and logs a formatted error message to the Unity console on failure.</para>
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void AssertFormat(
      bool condition,
      Object context,
      string format,
      params object[] args)
    {
      if (condition)
        return;
      Debug.unityLogger.LogFormat(LogType.Assert, context, format, args);
    }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an assertion message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void LogAssertion(object message)
    {
      Debug.unityLogger.Log(LogType.Assert, message);
    }

    /// <summary>
    ///   <para>A variant of Debug.Log that logs an assertion message to the console.</para>
    /// </summary>
    /// <param name="message">String or object to be converted to string representation for display.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void LogAssertion(object message, Object context)
    {
      Debug.unityLogger.Log(LogType.Assert, message, context);
    }

    /// <summary>
    ///   <para>Logs a formatted assertion message to the Unity console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void LogAssertionFormat(string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Assert, format, args);
    }

    /// <summary>
    ///   <para>Logs a formatted assertion message to the Unity console.</para>
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional("UNITY_ASSERTIONS")]
    public static void LogAssertionFormat(Object context, string format, params object[] args)
    {
      Debug.unityLogger.LogFormat(LogType.Assert, context, format, args);
    }

    /// <summary>
    ///   <para>In the Build Settings dialog there is a check box called "Development Build".</para>
    /// </summary>
    [NativeProperty(TargetType = TargetType.Field)]
    [StaticAccessor("GetBuildSettings()", StaticAccessorType.Dot)]
    public static extern bool isDebugBuild { [MethodImpl(MethodImplOptions.InternalCall)] get; }

    [FreeFunction("DeveloperConsole_OpenConsoleFile")]
    [MethodImpl(MethodImplOptions.InternalCall)]
    internal static extern void OpenConsoleFile();

    [NativeThrows]
    internal static extern DiagnosticSwitch[] diagnosticSwitches { [MethodImpl(MethodImplOptions.InternalCall)] get; }

    internal static DiagnosticSwitch GetDiagnosticSwitch(string name)
    {
      foreach (DiagnosticSwitch diagnosticSwitch in Debug.diagnosticSwitches)
      {
        if (diagnosticSwitch.name == name)
          return diagnosticSwitch;
      }
      throw new ArgumentException("Could not find DiagnosticSwitch named " + name);
    }

    [RequiredByNativeCode]
    internal static bool CallOverridenDebugHandler(Exception exception, Object obj)
    {
      if (Debug.unityLogger.logHandler is DebugLogHandler)
        return false;
      try
      {
        Debug.unityLogger.LogException(exception, obj);
      }
      catch (Exception ex)
      {
        Debug.s_DefaultLogger.LogError(string.Format("Invalid exception thrown from custom {0}.LogException(). Message: {1}", (object) Debug.unityLogger.logHandler.GetType(), (object) ex), (object) obj);
        return false;
      }
      return true;
    }

    [RequiredByNativeCode]
    internal static bool IsLoggingEnabled()
    {
      return Debug.unityLogger.logHandler is DebugLogHandler ? Debug.unityLogger.logEnabled : Debug.s_DefaultLogger.logEnabled;
    }

    [MethodImpl(MethodImplOptions.InternalCall)]
    internal static extern void LogSticky(
      int identifier,
      LogType logType,
      LogOption logOptions,
      string message,
      Object context = null);

    [MethodImpl(MethodImplOptions.InternalCall)]
    internal static extern void RemoveLogEntriesByIdentifier(int identifier);

    [EditorBrowsable(EditorBrowsableState.Never)]
    [Conditional("UNITY_ASSERTIONS")]
    [Obsolete("Assert(bool, string, params object[]) is obsolete. Use AssertFormat(bool, string, params object[]) (UnityUpgradable) -> AssertFormat(*)", true)]
    public static void Assert(bool condition, string format, params object[] args)
    {
      if (condition)
        return;
      Debug.unityLogger.LogFormat(LogType.Assert, format, args);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("Debug.logger is obsolete. Please use Debug.unityLogger instead (UnityUpgradable) -> unityLogger")]
    public static ILogger logger => Debug.s_Logger;

    [MethodImpl(MethodImplOptions.InternalCall)]
    private static extern void DrawLine_Injected(
      ref Vector3 start,
      ref Vector3 end,
      [UnityEngine.Internal.DefaultValue("Color.white")] ref Color color,
      [UnityEngine.Internal.DefaultValue("0.0f")] float duration,
      [UnityEngine.Internal.DefaultValue("true")] bool depthTest);
  }
}
